____ _ _ _ _
| _ \ ___ | |_ (_) _ __ ___ __| | (_) __ _
| |_) | / _ \ | __| | | | '_ \ / _ \ / _| | | | / _ |
| _ < | __/ | |_ | | | |_) | | __/ | (_| | | | | (_| |
|_| \_\ \___| \__| |_| | .__/ \___| \__,_| |_| \__,_|
|_|
- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b
¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
Lineare Suche
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
top
Lineare Suche ist ein Algorithmus, der auch unter dem Namen sequentielle Suche bekannt ist. Er ist der einfachste Suchalgorithmus überhaupt.
Die Aufgabe besteht darin, ein Element in einer Liste oder einem Array mit n Elementen zu finden. Man geht dazu die Liste Element für Element durch, bis man es gefunden hat. Der Suchaufwand wächst linear mit der Anzahl der Elemente in der Liste.
Die effizientere Binäre Suche kann nur bei geordneten Listen benutzt werden.
Für ungeordnete Listen existiert mit Lazy Select noch ein randomisierter Algorithmus, der mit relativ hoher Wahrscheinlichkeit das x-te Element einer Liste bezüglich einer Ordnung schneller als in linearer Zeit finden kann.
Contents
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
Komplexität
Die lineare Suche befindet sich in der Komplexitätsklasse O(n), da sie im schlechtesten Fall (wenn der gesuchte Wert nicht gefunden werden kann) n Vergleiche benötigt.
Wenn die Daten zufallsverteilt sind, dann werden im Schnitt (n+1)/2 Vergleichsoperationen benötigt.
Im besten Fall ist gleich das erste Element der Liste dasjenige, das man sucht.
Wenn die Anzahl der Elemente in einer Liste klein ist, dann ist es oft auch das effizienteste Verfahren.
Implementierungen (Beispiele)
Implementierung in Pseudocode
BEGINN LinearSearch
EINGABE: (S)uchschlüssel, (A)rray
VARIABLE: N = Anzahl Elemente im Array 'A'
VARIABLE: SucheErfolgreich = falsch
VARIABLE: i = 0
FÜR i BIS N ODER SucheErfolgreich
WENN A[i] = S
DANN SucheErfolgreich = wahr
WENN SucheErfolgreich = wahr
DANN AUSGABE: i
SONST AUSGABE: Suche nicht erfolgreich
ENDE
Beispielimplementierung in Ruby
# Falls der Wert nicht gefunden wird, gibt die Methode nil zurück.
def lineare_suche(liste, gesucht)
liste.each_with_index do |wert, index|
return index if wert == gesucht
end
nil
end
# bzw.
liste.index(gesucht)
Beispielimplementierung in Delphi bzw. Free Pascal
// Durchsucht ein Array of Integer nach einem gesuchten Integer-Wert.
// Wird der gesuchte Wert gefunden, gibt die Funktion den Index des Wertes zurück.
// Falls der Wert nicht gefunden wird, gibt die Funktion -1 zurück.
function LineareSuche(gesucht : integer; ADaten : array of integer) : integer;
var
c : integer;
begin
Result := -1;
for c := Low(ADaten) to High(ADaten) do
if gesucht = ADaten[c] then
Result := c;
end;
Beispielimplementierung in Objective CAML
let rec linsuche = function
([],a) -> false
| (x::t,a) -> if x = a then true else linsuche(t,a);;
Beispielimplementierung in Java
Das Beispiel gibt den Wert -1 zurück, wenn das gesuchte Element nicht im Array daten vorhanden ist. Ansonsten gibt es die Position des Elementes zurück.
public static int lineareSuche(final int gesucht, final int[] daten) {
for (int i = 0; i < daten.length; i++) {
if (daten[i] == gesucht) {
return i;
}
}
return -1;
}
Beispielimplementierung in Python
Findet alle Suchschlüssel in der Liste.
def lineare_suche(liste, gesucht):
idxs = []
for index, element in enumerate(liste):
if element == gesucht:
idxs.append(index)
return idxs
# bzw.
lineare_suche = lambda l,g : [i for i,e in enumerate(l) if g == e]
Findet erstes Vorkommen des Suchschlüssels in einer Liste.
def lineare_suche(liste, gesucht):
for index, element in enumerate(liste):
if element == gesucht:
return index
# bzw. gibt es schon
lineare_suche = lambda l,g : l.index(g) if g in l else None
Beispielimplementierung in C
Findet ersten Suchschlüssel (Ganzzahl) in der Liste.
#include <stdio.h>
/*
int*daten = Zeiger auf zu durchsuchende Daten
int datenlaenge = Größe des zu durchsuchenden "Arrays"
int suche = Gesuchte Ganzzahl
*/
int suche_sequenziell(int*daten, int datenlaenge, int suche) {
int i;
for (i=0;i<datenlaenge;i++)
if (daten[i]==suche)
return i;
return -1;
}
/* Beispielaufruf */
int main(void) {
int datenArray[10] = { 81, 1203, 180, 42, 10, 566, 102, 751, 54, 648 };
int pos = suche_sequenziell(datenArray, 10, 42);
/* -1 für nicht gefunden, ansonsten (erste) Position im Array, mit 0 beginnend */
if (pos<0)
printf("Nicht gefunden");
else
printf("Gefunden an Position %d",pos);
return 0;
}
Siehe auch